/**
 * AI聊天API工具类
 * 统一管理与后端ChatAI服务的API交互
 */

class AiApiService {
	constructor() {
		// 后端ChatAI服务的基础URL
		this.baseUrl = 'http://localhost:9007/api/ai'
		this.timeout = 30000 // 30秒超时，给AI更多处理时间
		this.retryCount = 1 // 1次重试，避免过多重试
	}

	/**
	 * 发送聊天消息到AI服务
	 * @param {String} message 用户消息
	 * @param {String} userId 用户ID（可选）
	 * @returns {Promise} AI回复的Promise
	 */
	async sendMessage(message, userId = null) {
		if (!message || !message.trim()) {
			throw new Error('消息内容不能为空')
		}

		const requestData = {
			message: message.trim(),
			user: userId || this.generateGuestUserId()
		}

		console.log('🤖 [AI API] 发送AI消息:', requestData)
		console.log('🌐 [AI API] 基础URL:', this.baseUrl)

		try {
			const response = await this.makeRequest('/chat', 'POST', requestData)
			
			if (response.success) {
				console.log('AI回复成功:', response.content)
				return {
					success: true,
					content: response.content,
					user: response.user
				}
			} else {
				throw new Error(response.message || 'AI服务返回错误')
			}
		} catch (error) {
			console.error('AI消息发送失败:', error)
			throw new Error(this.getErrorMessage(error))
		}
	}

	/**
	 * 流式发送聊天消息到AI服务
	 * @param {String} message 用户消息
	 * @param {Function} onChunk 接收流式数据的回调函数
	 * @param {String} userId 用户ID（可选）
	 * @returns {Promise} 流式回复的Promise
	 */
	async sendMessageStream(message, onChunk, userId = null) {
		if (!message || !message.trim()) {
			throw new Error('消息内容不能为空')
		}

		const requestData = {
			message: message.trim(),
			user: userId || this.generateGuestUserId()
		}

		console.log('🌊 [AI API] 发送流式AI消息:', requestData)

		try {
			// 先获取完整回复
			const response = await this.makeRequest('/chat', 'POST', requestData)
			
			if (response.success && response.content) {
				console.log('📝 [AI API] 开始流式输出:', response.content.length, '字符')
				
				// 模拟流式输出效果
				const content = response.content
				let currentText = ''
				
				// 按字符逐个输出，实现打字机效果
				for (let i = 0; i < content.length; i++) {
					currentText += content[i]
					
					// 调用回调函数更新UI
					if (onChunk && typeof onChunk === 'function') {
						onChunk(currentText, false) // false表示还未完成
					}
					
					// 控制输出速度：标点符号稍慢，普通字符较快
					const char = content[i]
					let delay = 30 // 默认30ms
					
					if ('。！？；：'.includes(char)) {
						delay = 200 // 句号等停顿200ms
					} else if ('，、'.includes(char)) {
						delay = 100 // 逗号等停顿100ms
					} else if ('\n'.includes(char)) {
						delay = 150 // 换行停顿150ms
					}
					
					// 等待指定时间
					await this.delay(delay)
				}
				
				// 最后调用一次表示完成
				if (onChunk && typeof onChunk === 'function') {
					onChunk(content, true) // true表示已完成
				}
				
				return {
					success: true,
					content: content,
					user: response.user
				}
			} else {
				throw new Error(response.message || 'AI服务返回错误')
			}
		} catch (error) {
			console.error('AI流式消息发送失败:', error)
			throw new Error(this.getErrorMessage(error))
		}
	}

	/**
	 * 检查AI服务健康状态
	 * @returns {Promise} 健康检查结果
	 */
	async checkHealth() {
		try {
			console.log('🏥 开始AI服务健康检查，URL:', `${this.baseUrl}/health`);
			const response = await this.makeRequest('/health', 'GET')
			console.log('✅ AI服务健康检查成功:', response);
			return {
				success: true,
				status: response.status,
				service: response.service
			}
		} catch (error) {
			console.error('❌ AI服务健康检查失败:', error)
			
			// 尝试简化的ping测试
			try {
				console.log('🔄 尝试简化的AI服务连接测试...');
				const simpleTest = await this.simplePing();
				if (simpleTest) {
					console.log('✅ 简化测试成功，AI服务可能可用');
					return {
						success: true,
						status: 'UP',
						service: 'ChatAI Service (简化检查)',
						fallback: true
					}
				}
			} catch (pingError) {
				console.error('❌ 简化测试也失败:', pingError);
			}
			
			return {
				success: false,
				error: this.getErrorMessage(error)
			}
		}
	}

	/**
	 * 简化的ping测试
	 * @returns {Promise<boolean>} 是否连接成功
	 */
	async simplePing() {
		return new Promise((resolve) => {
			uni.request({
				url: `${this.baseUrl}/health`,
				method: 'GET',
				timeout: 5000, // 5秒超时
				success: (res) => {
					console.log('🟢 简化ping成功:', res.statusCode);
					resolve(res.statusCode === 200);
				},
				fail: (err) => {
					console.log('🔴 简化ping失败:', err);
					resolve(false);
				}
			});
		});
	}

	/**
	 * 通用HTTP请求方法
	 * @param {String} endpoint API端点
	 * @param {String} method HTTP方法
	 * @param {Object} data 请求数据
	 * @param {Number} retryCount 重试次数
	 * @returns {Promise} 请求结果
	 */
	async makeRequest(endpoint, method = 'GET', data = null, retryCount = this.retryCount) {
		const url = `${this.baseUrl}${endpoint}`
		
		const options = {
			method: method,
			timeout: this.timeout,
			header: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		}

		// 添加请求体数据
		if (data && (method === 'POST' || method === 'PUT')) {
			options.data = data
		}

		try {
			console.log(`AI API请求: ${method} ${url}`, data)
			
			// 使用uni.request发送请求
			const response = await this.uniRequest(options, url)
			
			console.log('AI API响应:', response)
			return response.data
			
		} catch (error) {
			console.error(`AI API请求失败 (重试次数剩余: ${retryCount}):`, error)
			
			// 如果还有重试次数，则重试
			if (retryCount > 0 && this.shouldRetry(error)) {
				console.log('正在重试AI API请求...')
				await this.delay(3000) // 等待3秒后重试，给后端更多恢复时间
				return this.makeRequest(endpoint, method, data, retryCount - 1)
			}
			
			throw error
		}
	}

	/**
	 * uni.request的Promise封装
	 * @param {Object} options 请求选项
	 * @param {String} url 请求URL
	 * @returns {Promise} 请求Promise
	 */
	uniRequest(options, url) {
		return new Promise((resolve, reject) => {
			uni.request({
				url: url,
				...options,
				success: (res) => {
					if (res.statusCode >= 200 && res.statusCode < 300) {
						resolve(res)
					} else {
						reject(new Error(`HTTP ${res.statusCode}: ${res.data?.message || '请求失败'}`))
					}
				},
				fail: (err) => {
					reject(new Error(err.errMsg || '网络请求失败'))
				}
			})
		})
	}

	/**
	 * 判断是否应该重试请求
	 * @param {Error} error 错误对象
	 * @returns {Boolean} 是否应该重试
	 */
	shouldRetry(error) {
		const retryableErrors = [
			'网络请求失败',
			'timeout',
			'连接超时',
			'服务器异常',
			'HTTP 500',
			'HTTP 502',
			'HTTP 503',
			'HTTP 504'
		]
		
		const errorMessage = error.message || ''
		return retryableErrors.some(retryableError => 
			errorMessage.includes(retryableError)
		)
	}

	/**
	 * 获取友好的错误信息
	 * @param {Error} error 错误对象
	 * @returns {String} 友好的错误信息
	 */
	getErrorMessage(error) {
		const errorMessage = error.message || ''
		
		if (errorMessage.includes('timeout') || errorMessage.includes('连接超时')) {
			return 'AI服务连接超时，请检查网络连接'
		}
		
		if (errorMessage.includes('网络请求失败')) {
			return 'AI服务连接失败，请检查服务是否启动'
		}
		
		if (errorMessage.includes('HTTP 500')) {
			return 'AI服务内部错误，请稍后重试'
		}
		
		if (errorMessage.includes('HTTP 503')) {
			return 'AI服务暂时不可用，请稍后重试'
		}
		
		// 返回原始错误信息
		return errorMessage || '未知错误'
	}

	/**
	 * 生成访客用户ID
	 * @returns {String} 访客用户ID
	 */
	generateGuestUserId() {
		// 尝试获取存储的访客ID
		let guestId = null
		try {
			guestId = uni.getStorageSync('ai_guest_id')
		} catch (error) {
			console.log('获取访客ID失败:', error)
		}
		
		// 如果没有访客ID，生成一个新的
		if (!guestId) {
			guestId = 'guest_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9)
			try {
				uni.setStorageSync('ai_guest_id', guestId)
			} catch (error) {
				console.log('存储访客ID失败:', error)
			}
		}
		
		return guestId
	}

	/**
	 * 延迟函数
	 * @param {Number} ms 延迟毫秒数
	 * @returns {Promise} 延迟Promise
	 */
	delay(ms) {
		return new Promise(resolve => setTimeout(resolve, ms))
	}

	/**
	 * 设置基础URL
	 * @param {String} url 新的基础URL
	 */
	setBaseUrl(url) {
		this.baseUrl = url
		console.log('AI API基础URL已更新为:', this.baseUrl)
	}

	/**
	 * 设置超时时间
	 * @param {Number} timeout 超时时间（毫秒）
	 */
	setTimeout(timeout) {
		this.timeout = timeout
		console.log('AI API超时时间已更新为:', this.timeout, 'ms')
	}

	/**
	 * 获取用户ID（优先从用户信息获取）
	 * @returns {String} 用户ID
	 */
	getUserId() {
		try {
			// 尝试获取登录用户信息
			const userInfo = uni.getStorageSync('userInfo')
			if (userInfo && userInfo.id) {
				return userInfo.id.toString()
			}
			
			// 如果没有登录用户，使用访客ID
			return this.generateGuestUserId()
		} catch (error) {
			console.log('获取用户ID失败，使用访客ID:', error)
			return this.generateGuestUserId()
		}
	}
}

// 创建全局实例
const aiApiService = new AiApiService()

// 导出实例和类
export default aiApiService
export { AiApiService }
